package com.jgc.blockingqueue;

import org.junit.Test;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class BolckingQueueTest {
    static ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(4);

    static {
        queue.add(1);
        queue.add(2);
        queue.add(3);
    }

    @Test
    //尾部加入 ，满了返回false
    //如果队列没满，返回true，如果队列已满，返回false（不堵塞）
    public void TestOffer() throws InterruptedException {
        queue.offer(2);
        queue.offer(2,10, TimeUnit.SECONDS);
        System.out.println(queue.size());
    }

    /**
     * （1）offer(E e)：如果队列没满，返回true，如果队列已满，返回false（不堵塞）
     * （2）offer(E e, long timeout, TimeUnit unit)：可以设置等待时间，如果队列已满，则进行等待。超过等待时间，则返回false
     * （3）put(E e)：无返回值，一直等待，直至队列空出位置
     */
    @Test
    public void putTest(){
        //put(E e)：无返回值，一直等待，直至队列空出位置
        try {
            queue.put(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * （1）poll()：如果有数据，出队，如果没有数据，返回null
     * （2）poll(long timeout, TimeUnit unit)：可以设置等待时间，如果没有数据，则等待，超过等待时间，则返回null
     * （3）take()：如果有数据，出队。如果没有数据，一直等待（堵塞）
     */
    @Test
    public void TestPoll() throws InterruptedException {
        Integer poll = queue.poll();//果队列没满，返回true，如果队列已满，返回false（不堵塞）
        Integer poll2 = queue.poll(10,TimeUnit.SECONDS);
    }
    @Test public void testTake() throws InterruptedException {
//        如果有数据，出队。如果没有数据，一直等待
        Integer take = queue.take();
    }

    @Test
    public void TestPeek() {
        Integer peek = queue.peek();
        System.out.println(peek);
    }
}
